home *** CD-ROM | disk | FTP | other *** search
/ Aminet 43 / Aminet 43 (2001)(GTI - Schatztruhe)[!][Jun 2001].iso / Aminet / dev / moni / SystemViewer.lha / Source / GlobalObjects / CommonFuncs.c next >
Encoding:
C/C++ Source or Header  |  2001-04-03  |  44.2 KB  |  1,805 lines
  1. /****h* CommonFuncs.c [2.1] *********************************************
  2. *
  3. * NAME
  4. *    CommonFuncs.c
  5. *
  6. * DESCRIPTION
  7. *    Functions that get used a lot for GUI programming, especially for
  8. *    GadToolsBox-generated GUIs.  This file is used to generate 
  9. *    CommonFuncs.o - a Link-able Object for the SAS-C (V6.58) compiler.
  10. *
  11. *    This a link-able object because there are far too many shared 
  12. *    libraries for the Amiga OS as it is, I couldn't see cluttering 
  13. *    someone's hard drive with another one (especially my own!).
  14. *
  15. * HISTORY
  16. *    03-Apr-2001 - Added the SetupList() function.
  17. *    25-Sep-2000 - Added the GetActiveScreen() function.
  18. *    24-Sep-2000 - Added DisplayTitle() & UserInfo() functions.
  19. *    17-Sep-2000 - Added SetTagPair(), Guarded_FreeLV(), &
  20. *                  Guarded_AllocLV() functions.
  21. *    28-Aug-2000 - Added GetPathName() function.
  22. *    18-May-2000 - Added FontXDim() function.
  23. *    17-May-2000 - Added GetScreenModeID() function.
  24. *    19-Jan-2000 - Changed FileReq() to check for NULL parameter. 
  25. *                  Added File_DirReq() function.
  26. *
  27. * AUTHOR
  28. *    James T. Steichen
  29. *    2217 N. Tamarack Dr.
  30. *    Slayton, Mn. 56172-1155, USA
  31. *    jimbot@rconnect.com
  32. *
  33. * NOTES
  34. *    $VER: CommonFuncs.c 2.1 (03-Apr-2001) by J.T. Steichen
  35. *
  36. * COPYRIGHT
  37. *    CommonFuncs.c & CommonFuncs.h (c) 1999-2001 by J.T. Steichen
  38. *************************************************************************
  39. *
  40. */
  41.  
  42. #include <stdio.h>
  43.  
  44. #include <AmigaDOSErrs.h>
  45.  
  46. #include <exec/types.h>
  47. #include <exec/nodes.h>
  48. #include <exec/lists.h>
  49. #include <exec/memory.h>
  50. #include <exec/libraries.h>
  51.  
  52. #include <libraries/asl.h>
  53. #include <libraries/gadtools.h>
  54.  
  55. #include <intuition/intuitionbase.h>
  56. #include <intuition/intuition.h>
  57.  
  58. #include <graphics/view.h>
  59. #include <graphics/gfxbase.h>
  60. #include <graphics/gfxmacros.h>
  61.  
  62. #include <workbench/workbench.h>
  63.  
  64. #include <dos/dos.h>
  65.  
  66. #include <clib/dos_protos.h>
  67. #include <clib/exec_protos.h>
  68. #include <clib/intuition_protos.h>
  69. #include <clib/graphics_protos.h>
  70.  
  71. #include "CommonFuncs.h"
  72.  
  73. IMPORT __far struct IntuitionBase *IntuitionBase;
  74. IMPORT __far struct GfxBase       *GfxBase;
  75. IMPORT __far struct Library       *GadToolsBase;
  76. IMPORT __far struct Library       *AslBase;
  77.  
  78. // ----------------------------------------------------------------------
  79.  
  80. /****h* SetupList() *****************************************************
  81. *
  82. * NAME
  83. *    SetupList()
  84. *
  85. * SYNOPSIS
  86. *    void SetupList( struct List *lst, struct ListViewMem *lvm );
  87. *
  88. * DESCRIPTION
  89. *    Initialize a List structure for a ListView Gadget.
  90. *************************************************************************
  91. *
  92. */
  93.  
  94. PUBLIC void SetupList( struct List *list, struct ListViewMem *lvm )
  95. {
  96.    int i, len = lvm->lvm_NodeLength;
  97.  
  98.    if (lvm->lvm_NumItems < 256)
  99.       {
  100.       // We can prioritize the nodes:
  101.       for (i = 0; i < lvm->lvm_NumItems; i++)
  102.          {
  103.          lvm->lvm_Nodes[i].ln_Name = &lvm->lvm_NodeStrs[ i * len ];
  104.          lvm->lvm_Nodes[i].ln_Pri  = lvm->lvm_NumItems - i - 129;
  105.          lvm->lvm_Nodes[i].ln_Type = NT_USER;
  106.          }
  107.  
  108.       NewList( list );
  109.  
  110.       for (i = 0; i < lvm->lvm_NumItems; i++)
  111.          Enqueue( list, &(lvm->lvm_Nodes[i]) );
  112.       }
  113.    else
  114.       {
  115.       // Too many nodes to use priorities:
  116.       for (i = 0; i < lvm->lvm_NumItems; i++)
  117.          {
  118.          lvm->lvm_Nodes[i].ln_Name = &lvm->lvm_NodeStrs[ i * len ];
  119.          lvm->lvm_Nodes[i].ln_Pri  = 0;
  120.          lvm->lvm_Nodes[i].ln_Type = NT_USER;
  121.          }
  122.  
  123.       NewList( list );
  124.  
  125.       for (i = 0; i < lvm->lvm_NumItems; i++)
  126.          AddTail( list, &(lvm->lvm_Nodes[i]) );
  127.       }
  128.  
  129.    return;
  130. }
  131.  
  132. /****h* GetActiveScreen() ***********************************************
  133. *
  134. * NAME
  135. *    GetActiveScreen()
  136. *
  137. * SYNOPSIS
  138. *    struct Screen *active = GetActiveScreen( void );
  139. *
  140. * DESCRIPTION
  141. *    Return a pointer to the Active Screen.
  142. *************************************************************************
  143. *
  144. */
  145.  
  146. PUBLIC struct Screen *GetActiveScreen( void )
  147. {
  148.    struct Screen *rval  = NULL;
  149.    ULONG          ilock = 0L;
  150.  
  151.    if (IntuitionBase == NULL)
  152.       return( rval );         // Kill any potential bugs here.
  153.       
  154.    ilock = LockIBase( NULL );
  155.    
  156.       rval = IntuitionBase->ActiveScreen;
  157.       
  158.    UnlockIBase( ilock );
  159.    
  160.    return( rval );     
  161. }
  162.  
  163. /****h* DisplayTitle() **************************************************
  164. *
  165. * NAME
  166. *    DisplayTitle()
  167. *
  168. * SYNOPSIS
  169. *    void DisplayTitle( struct Window *wptr, char *windowTitle );
  170. *
  171. * DESCRIPTION
  172. *    Display the given text as a title for the given Window.
  173. *
  174. * NOTES
  175. *    The title is silently limited to 79 characters in length.
  176. *************************************************************************
  177. *
  178. */
  179.  
  180. PUBLIC void DisplayTitle( struct Window *wptr, char *txt )
  181. {
  182.    static char tbuf[80];
  183.  
  184.    if (txt == NULL)
  185.       return;         // Stop bugs in their tracks!
  186.       
  187.    if (wptr == NULL)
  188.       return;         // Stop bugs in their tracks!
  189.          
  190.    strncpy( &tbuf[0], txt, 79 );
  191.  
  192.    SetWindowTitles( wptr, (UBYTE *) &tbuf[0], (UBYTE *) -1 );
  193.    
  194.    return;
  195. }
  196.  
  197. // ----------------------------------------------------------------------
  198.  
  199. PUBLIC int LVMError = 0; // Error # for Guarded_AllocLV() function.
  200.  
  201. /****h* Guarded_FreeLV() ************************************************
  202. *
  203. * NAME
  204. *    Guarded_FreeLV()
  205. *
  206. * SYNOPSIS
  207. *    void Guarded_FreeLV( struct ListViewMem *lvm );
  208. *
  209. * DESCRIPTION
  210. *    Free the memory associated with a ListView Gadget & reset 
  211. *    the Guard. 
  212. *************************************************************************
  213. *
  214. */
  215.  
  216. PUBLIC void Guarded_FreeLV( struct ListViewMem *lvm )
  217. {
  218.    if (lvm == NULL)
  219.       return;
  220.       
  221.    if (lvm->lvm_NodeStrs != NULL)
  222.       {
  223.       FreeVec( lvm->lvm_NodeStrs );
  224.       lvm->lvm_NodeStrs = NULL;
  225.       }
  226.  
  227.    if (lvm->lvm_Nodes != NULL)
  228.       {
  229.       FreeVec( lvm->lvm_Nodes );
  230.       lvm->lvm_Nodes = NULL;
  231.       }
  232.  
  233.    if (lvm != NULL)
  234.       {
  235.       FreeVec( lvm );
  236.       lvm = NULL;
  237.       }
  238.  
  239.    return;
  240. }
  241.  
  242. /****h* ReportAllocLVError() ********************************************
  243. *
  244. * NAME
  245. *    ReportAllocLVError()
  246. *
  247. * SYNOPSIS
  248. *    void ReportAllocLVError( void );
  249. *
  250. * DESCRIPTION
  251. *    Display a requester informing the User the error that 
  252. *    Guarded_AllocLV() found.
  253. *
  254. * SEE ALSO
  255. *    Guarded_AllocLV(), Guarded_FreeLV()
  256. *************************************************************************
  257. *
  258. */
  259.  
  260. PUBLIC void ReportAllocLVError( void )
  261. {
  262.    IMPORT int LVMError;
  263.  
  264.    char msg[256];
  265.       
  266.    switch (LVMError)
  267.       {
  268.       case LVM_ERROR_NONE:
  269.          sprintf( &msg[0], "No Guarded_AllocLV() error found!" );
  270.          break;
  271.        
  272.       case LVM_ERROR_WRONG_SIZE:
  273.          sprintf( &msg[0], "Guarded_AllocLV() sizes < 1 (Wrong Size!)" );
  274.          break;
  275.          
  276.       case LVM_ERROR_NOMEM:
  277.          sprintf( &msg[0], "Guarded_AllocLV() ran out of Memory!" );
  278.          break;
  279.       } 
  280.  
  281.    UserInfo( &msg[0], "ERROR Report:" );
  282.  
  283.    return;
  284. }
  285.  
  286. /****h* Guarded_AllocLV() ***********************************************
  287. *
  288. * NAME
  289. *    Guarded_AllocLV()
  290. *
  291. * SYNOPSIS
  292. *    struct ListViewMem *lvm = Guarded_AllocLV( int numitems, 
  293. *                                               int itemsize
  294. *                                             );
  295. *
  296. * DESCRIPTION
  297. *    Allocate the memory associated with a ListView Gadget.
  298. *************************************************************************
  299. *
  300. */
  301.  
  302. PUBLIC struct ListViewMem *Guarded_AllocLV( int numitems, int itemsize )
  303. {
  304.    IMPORT int LVMError;
  305.    
  306.    struct ListViewMem *rval = NULL;
  307.    
  308.    if ((numitems < 1) || (itemsize < 1))
  309.       {
  310.       LVMError = LVM_ERROR_WRONG_SIZE;
  311.       
  312.       return( NULL );
  313.       }
  314.  
  315.    // --------- ALLOCATION SECTION: -----------------------------------
  316.  
  317.    rval = (struct ListViewMem *) AllocVec( sizeof( struct ListViewMem ),
  318.                                            MEMF_CLEAR
  319.                                          );  
  320.    
  321.    if (rval == NULL)
  322.       {
  323.       LVMError = LVM_ERROR_NOMEM;
  324.  
  325.       return( NULL );
  326.       }
  327.  
  328.    rval->lvm_Nodes = (struct Node *) 
  329.                       AllocVec( numitems * sizeof( struct Node ),
  330.                                 MEMF_CLEAR 
  331.                               );
  332.  
  333.    if (rval->lvm_Nodes == NULL)
  334.       {
  335.       Guarded_FreeLV( rval );
  336.  
  337.       LVMError = LVM_ERROR_NOMEM;
  338.  
  339.       return( NULL );
  340.       }
  341.  
  342.    rval->lvm_NodeStrs = (UBYTE *) AllocVec( numitems * itemsize, 
  343.                                             MEMF_CLEAR
  344.                                           );
  345.  
  346.    if (rval->lvm_NodeStrs == NULL)
  347.       {
  348.       Guarded_FreeLV( rval );
  349.  
  350.       LVMError = LVM_ERROR_NOMEM;
  351.  
  352.       return( NULL );
  353.       }
  354.  
  355.    // --------- END OF ALLOCATION SECTION: ----------------------------
  356.  
  357.    rval->lvm_NumItems   = numitems;
  358.    rval->lvm_NodeLength = itemsize;   
  359.  
  360.    LVMError = LVM_ERROR_NONE; // Weesa be okey-dokey!
  361.  
  362.    return( rval );
  363. }
  364.  
  365. /****h* GetPathName() ***************************************************
  366. *
  367. * NAME
  368. *    GetPathName()
  369. *  
  370. * SYNOPSIS
  371. *    char *path = GetPathName( char *pathbuf, char *filename, int size );
  372. *
  373. * DESCRIPTION
  374. *    Return with the Path portion of a filename string.
  375. *************************************************************************
  376. *
  377. */
  378.  
  379. PUBLIC char *GetPathName( char *path, char *filename, int size )
  380. {
  381.    int   i;
  382.    char *last = PathPart( filename );
  383.  
  384.    for (i = 0; (i < size) && (filename != last); i++, filename++)
  385.       *(path + i) = *filename;
  386.       
  387.    *(path + i) = '\0';
  388.    
  389.    return( path ); 
  390. }
  391.  
  392.  
  393. /****h* FontXDim() ******************************************************
  394. *
  395. * NAME
  396. *    FontXDim()
  397. *
  398. * SYNOPSIS
  399. *    int length = FontXDim( struct TextAttr *font );
  400. *
  401. * DESCRIPTION
  402. *    Determine the horizontal distance for one character in the given
  403. *    font.
  404. *************************************************************************
  405. *
  406. */
  407.  
  408. PUBLIC int FontXDim( struct TextAttr *font )
  409. {
  410.    struct IntuiText t = { 0, };
  411.     
  412.    t.IText     = " ";
  413.    t.ITextFont = font;
  414.    
  415.    return( IntuiTextLength( &t ) );
  416. }
  417.  
  418. /****h* getScreenModeID() ***********************************************
  419. *
  420. * NAME
  421. *    getScreenModeID()
  422. *
  423. * SYNOPSIS
  424. *    ULONG mode = getScreenModeID( struct TagItem *taglist, 
  425. *                                  struct Screen  *screen,
  426. *                                  char           *req_title
  427. *                                ); 
  428. *
  429. * DESCRIPTION
  430. *    Obtain a user-selected (via ASL) ScreenModeID value.  NULL will
  431. *    be returned if you supply a NULL value for the screen pointer,
  432. *    or if you press & release the Cancel Gadget on the Requester.
  433. *************************************************************************
  434. *
  435. */
  436.  
  437. PUBLIC ULONG getScreenModeID( struct TagItem *taglist, 
  438.                               struct Screen  *scr,
  439.                               char           *title 
  440.                             )
  441. {
  442.    struct ScreenModeRequester *smr = NULL;
  443.  
  444.    ULONG  rval    = NULL;
  445.    BOOL   result  = FALSE;
  446.    BOOL   libflag = FALSE;
  447.    
  448.    if (scr == NULL)
  449.       {
  450.       return( NULL ); // Better safe than sorry!
  451.       }
  452.       
  453.    if (FindTagItem( ASLSM_Screen, taglist ) == NULL)
  454.       {
  455.       return( NULL ); // Missing the ONLY necessary tag!
  456.       }
  457.    else
  458.       SetTagItem( taglist, ASLSM_Screen, (ULONG) scr );
  459.  
  460.    if (FindTagItem( ASLSM_TitleText, taglist ) != NULL)
  461.       SetTagItem( taglist, ASLSM_TitleText, (ULONG) title );
  462.                   
  463.    if ((AslBase = OpenLibrary( AslName, 37L )) != NULL)
  464.       libflag = TRUE;
  465.  
  466.    if (AslBase != NULL)
  467.       {
  468.       smr = (struct ScreenModeRequester *) 
  469.              AllocAslRequest( ASL_ScreenModeRequest, NULL );
  470.  
  471.       if (smr != NULL)
  472.          {
  473.          result = AslRequest( smr, taglist );
  474.  
  475.          if (result == TRUE)
  476.             {
  477.             rval = smr->sm_DisplayID;
  478.             } 
  479.  
  480.          FreeAslRequest( smr );
  481.          }
  482.       else                   // No ScreenModeRequester!
  483.          {
  484.          if (libflag != FALSE)
  485.             CloseLibrary( AslBase );
  486.  
  487.          return( NULL );
  488.          }
  489.  
  490.       if (libflag != FALSE)
  491.          CloseLibrary( AslBase );
  492.       }
  493.    else
  494.       {
  495.       return( NULL );          // AslBase couldn't be opened!
  496.       }
  497.  
  498.    if (result == TRUE)
  499.       return( rval );
  500.    else
  501.       return( NULL );
  502. }
  503.  
  504. /****h* Byt2Str() ***************************************************
  505. *
  506. * NAME
  507. *    Byt2Str()
  508. *
  509. * SYNOPSIS
  510. *    char *hexstr = Byt2Str( char *output, UBYTE input_byte );
  511. *
  512. * DESCRIPTION
  513. *    Take an input binary character & generate a displayable 
  514. *    two-character ASCII 
  515. *    string that displays the HexaDecimal value of each byte.
  516. *
  517. * WARNINGS
  518. *    The output buffer has to be TWO times as long as the input
  519. *    buffer (+ 1 for nil); in other words supply a buffer that's
  520. *    three characters long!
  521. *********************************************************************
  522. *
  523. */
  524.  
  525. PUBLIC char *Byt2Str( char *out, UBYTE input )
  526. {
  527.    UBYTE hexch[] = "0123456789ABCDEF";
  528.  
  529.    UBYTE low     = hexch[  input & 0x0F       ];
  530.    UBYTE high    = hexch[ (input & 0xF0) >> 4 ];
  531.  
  532.    *out       = high;
  533.    *(out + 1) = low;
  534.    *(out + 2) = '\0';
  535.  
  536.    return( out );
  537. }
  538.  
  539. /****h* MakeHexASCIIStr() *******************************************
  540. *
  541. * NAME
  542. *    MakeHexASCIIStr()
  543. *
  544. * SYNOPSIS
  545. *    unsigned int length = MakeHexASCIIStr( char *output, 
  546. *                                           char *input,
  547. *                                           int   inputlength
  548. *                                         );
  549. *
  550. * DESCRIPTION
  551. *    Take an input binary string & generate a displayable ASCII 
  552. *    string that displays the HexaDecimal value of each byte as
  553. *    well as the ASCII representation (for characters >= 0x20 &
  554. *    <= 0x7E).
  555. *
  556. *    Output will be as follows:
  557. *
  558. *    /------------ Hex Bytes ----------\ /--- ASCII ----\
  559. *
  560. *    22334455 22334455 A7223344 7F223344 "3DU"3DU."3D."3D 
  561. *
  562. * WARNINGS
  563. *    The output buffer has to be FOUR times as long as the input
  564. *    buffer!  The maximum value for inlen should be 20 bytes, with
  565. *    16 being the nominal value.
  566. *********************************************************************
  567. *
  568. */
  569.  
  570. PUBLIC unsigned int MakeHexASCIIStr( char *out, char *input, int inlen )
  571. {
  572.    UBYTE hexch[] = "0123456789ABCDEF";
  573.    int   i, j, k;
  574.  
  575.    for (i = 0; i < (4 * inlen); i++)
  576.       *(out + i) = ' ';         // Initialize the output buffer.
  577.  
  578.    // Output the binary as ASCII characters:  
  579.  
  580.    for (i = 0, j = 0, k = 0; i < inlen; i++, j++, k++)
  581.       {
  582.       UBYTE low, high;
  583.          
  584.       low  = hexch[  *(input + i) & 0x0F       ];
  585.       high = hexch[ (*(input + i) & 0xF0) >> 4 ];
  586.  
  587.       *(out + k + j)     = high;
  588.       *(out + k + j + 1) = low;
  589.       
  590.       if ((i + 1) % 4 == 0) // Insert a space between each long word.
  591.          k++;
  592.       }
  593.  
  594.    *(out + k + j) = '\0';
  595.    i = strlen( out );      // compute the start of the ASCII string.
  596.    *(out + k + j) = ' ';
  597.  
  598.    // Output the ASCII representation:   
  599.  
  600.    for (j = 0; j < inlen; j++, i++) 
  601.       {
  602.       if ((*(input + j) < 0x20) || (*(input + j) > 0x7E))
  603.          *(out + i) = 0x2E; /* Output an ASCII period. */
  604.       else
  605.          *(out + i) = *(input + j);
  606.       }
  607.  
  608.    return( (unsigned int) strlen( out ) );
  609. }
  610.  
  611. /****h* File_DirReq() ***************************************************
  612. * 
  613. * NAME
  614. *    File_DirReq()
  615. *
  616. * SYNOPSIS
  617. *    int len = File_DirReq( char           *filename, 
  618. *                           char           *dirname,
  619. *                           struct TagItem *taglist
  620. *                         );
  621. *
  622. * DESCRIPTION
  623. *    Display the ASL file requester with the given taglist.  Return
  624. *    the size of the file selected as well as the filename & Directory.
  625. *
  626. *    The suggested taglist items should be:
  627. *
  628. *    ASLFR_Window,          (ULONG) WindowPointer // definitely needed!
  629. *
  630. *    ASLFR_TitleText,       (ULONG) "Example title..." 
  631. *    ASLFR_InitialHeight,   200,
  632. *    ASLFR_InitialWidth,    400,
  633. *    ASLFR_InitialTopEdge,  16,
  634. *    ASLFR_InitialLeftEdge, 50,
  635. *    ASLFR_PositiveText,    (ULONG) "OKAY!",
  636. *    ASLFR_NegativeText,    (ULONG) "CANCEL!",
  637. *    ASLFR_InitialPattern,  (ULONG) "#?",
  638. *    ASLFR_InitialFile,     (ULONG) "",
  639. *    ASLFR_InitialDrawer,   (ULONG) "RAM:",
  640. *    ASLFR_Flags1,          FRF_DOPATTERNS,
  641. *    ASLFR_Flags2,          FRF_REJECTICONS,
  642. *    ASLFR_SleepWindow,     1,
  643. *    ASLFR_PrivateIDCMP,    1,
  644. *    TAG_END
  645. ************************************************************************
  646. *
  647. */
  648.  
  649. PUBLIC int File_DirReq( char           *filename, 
  650.                         char           *dirname, 
  651.                         struct TagItem *taglist
  652.                       )
  653. {
  654.    struct FileRequester *fr;
  655.  
  656.    int    len, libflag = 0;
  657.  
  658.    if (filename == NULL)
  659.       {
  660.       return( -4 ); // Better safe than sorry!
  661.       }
  662.       
  663.    if (FindTagItem( ASLFR_Window, taglist ) == NULL)
  664.       {
  665.       return( -3 ); // Missing the ONLY necessary tag!
  666.       }
  667.            
  668.    if ((AslBase = OpenLibrary( AslName, 37L )) != NULL)
  669.       libflag = 1;
  670.  
  671.    if (AslBase != NULL)
  672.       {
  673.       fr = (struct FileRequester *) 
  674.                    AllocAslRequest( ASL_FileRequest, taglist );
  675.  
  676.       if (fr != NULL)
  677.          {
  678.  
  679.          if (AslRequest( fr, NULL ))
  680.             {
  681.             (void) strcpy( filename, fr->fr_Drawer );
  682.             len = strlen( filename ) - 1;
  683.  
  684.             if (*(filename + len) == '/' || *(filename + len) == ':')
  685.                (void) strcat( filename, fr->fr_File );
  686.             else
  687.                {      
  688.                // Add a slash to the end of the Path:
  689.                (void) strcat( filename, "/" );
  690.                (void) strcat( filename, fr->fr_File );
  691.                }
  692.             }
  693.  
  694.          if (dirname != NULL)
  695.             strcpy( dirname, fr->fr_Drawer );
  696.  
  697.          FreeAslRequest( fr );
  698.          }
  699.       else                   // No FileRequester!
  700.          {
  701.          if (libflag > 0)
  702.             CloseLibrary( AslBase );
  703.  
  704.          return( -2 );
  705.          }
  706.  
  707.       if (libflag > 0)
  708.          CloseLibrary( AslBase );
  709.       }
  710.    else
  711.       {
  712.       return( -1 );          // AslBase couldn't be opened!
  713.       }
  714.  
  715.    return( strlen( filename ) );
  716. }
  717.  
  718. /****h* FileReq() ******************************************************
  719. * 
  720. * NAME
  721. *    FileReq()
  722. *
  723. * SYNOPSIS
  724. *    int len = FileReq( char *filename, struct TagItem *taglist );
  725. *
  726. * DESCRIPTION
  727. *    Display the ASL file requester with the given taglist.
  728. *
  729. * NOTES
  730. *    This function is identical to File_DirReq() except that we
  731. *    don't use the Directory parameter.
  732. *
  733. *    The suggested taglist items should be:
  734. *
  735. *    ASLFR_Window,          (ULONG) WindowPointer // definitely needed!
  736. *
  737. *    ASLFR_TitleText,       (ULONG) "Example title..." 
  738. *    ASLFR_InitialHeight,   200,
  739. *    ASLFR_InitialWidth,    400,
  740. *    ASLFR_InitialTopEdge,  16,
  741. *    ASLFR_InitialLeftEdge, 50,
  742. *    ASLFR_PositiveText,    (ULONG) "OKAY!",
  743. *    ASLFR_NegativeText,    (ULONG) "CANCEL!",
  744. *    ASLFR_InitialPattern,  (ULONG) "#?",
  745. *    ASLFR_InitialFile,     (ULONG) "",
  746. *    ASLFR_InitialDrawer,   (ULONG) "RAM:",
  747. *    ASLFR_Flags1,          FRF_DOPATTERNS,
  748. *    ASLFR_Flags2,          FRF_REJECTICONS,
  749. *    ASLFR_SleepWindow,     1,
  750. *    ASLFR_PrivateIDCMP,    1,
  751. *    TAG_END
  752. ************************************************************************
  753. *
  754. */
  755.  
  756. PUBLIC int FileReq( char *filename, struct TagItem *taglist )
  757. {
  758.    return( File_DirReq( filename, NULL, taglist ) );
  759. }
  760.  
  761. /* --------------------- User Notification: ------------------------ */
  762.  
  763. PRIVATE struct usernotify {
  764.     
  765.    struct EasyStruct un_ES;
  766.    struct Window     *un_Window;
  767. };
  768.  
  769. PRIVATE struct usernotify userinfo = {
  770.     
  771.    { sizeof( struct EasyStruct ), 0,
  772.      "Program Problem!",
  773.      "Problem (%ld) with Program.\nSelect 'ABORT' to quit:",
  774.      "CONTINUE|ABORT",
  775.    },
  776.  
  777.    NULL
  778. };
  779.  
  780. /****h* SetNotifyWindow() [1.0] *************************************
  781. *
  782. * NAME
  783. *    SetNotifyWindow()
  784. *
  785. * SYNOPSIS
  786. *    (void) SetNotifyWindow( struct Window *wptr );
  787. *
  788. * DESCRIPTION
  789. *    Set the window pointer that Handle_Problem() & other User-
  790. *    Requesters will use for the EasyRequest() call.
  791. *********************************************************************
  792. *
  793. */
  794.  
  795. PUBLIC void SetNotifyWindow( struct Window *wptr )
  796. {
  797.    if (wptr != NULL)
  798.       userinfo.un_Window = wptr;
  799.    
  800.    return;
  801. }
  802.  
  803. /****h* SetReqButtons() [1.0] ***************************************
  804. *
  805. * NAME
  806. *    SetReqButtons
  807. *
  808. * SYNOPSIS
  809. *    (void) SetReqButtons( char *newbuttons );
  810. *
  811. * DESCRIPTION
  812. *    Set the buttons for the Information requester to the given 
  813. *    format string.
  814. *
  815. * NOTES
  816. *    The user of this function should return the buttons to a
  817. *    known string after Handle_Problem() or the other User-
  818. *    requesters are called.
  819. *********************************************************************
  820. *
  821. */
  822.  
  823. PUBLIC void SetReqButtons( char *newbuttons )
  824. {
  825.    if (newbuttons != NULL)
  826.       userinfo.un_ES.es_GadgetFormat = newbuttons;
  827.    else
  828.       userinfo.un_ES.es_GadgetFormat = "CONTINUE|ABORT!";
  829.       
  830.    return;
  831. }
  832.  
  833. /****i* NotifyUser() [1.0] ******************************************
  834. *
  835. * NAME
  836. *    NotifyUser() - Internal to CommonFuncs.o only (PRIVATE!)
  837. *
  838. * SYNOPSIS
  839. *    int ans = NotifyUser( char          *info, 
  840. *                          char          *title,
  841. *                          struct Window *wptr, 
  842. *                          int           *errnum
  843. *                        );
  844. *
  845. * DESCRIPTION
  846. *    Get a response from the user.
  847. *
  848. * FUNCTION
  849. *    Return -1 if the user selected the far-right button (ABORT?),
  850. *    else return 0 (CONTINUE?).
  851. *
  852. * INPUTS
  853. *    info   - Information string for the user to act on.
  854. *    title  - Title of the Problem Requester.
  855. *    wptr   - The window to open the Requester on.
  856. *    errnum - Optional error number (normally NULL).
  857. *********************************************************************
  858. *
  859. */
  860.  
  861. PRIVATE int NotifyUser( char          *problem,
  862.                         char          *title,
  863.                         struct Window *wptr,
  864.                         int           errnum
  865.                       )
  866. {
  867.    int rval = 0, answer = 0;
  868.    int oldflags, newflags = wptr->IDCMPFlags;
  869.    
  870.    userinfo.un_ES.es_TextFormat = problem;
  871.    userinfo.un_ES.es_Title      = title;
  872.    oldflags                     = newflags;
  873.    
  874.    // Turn off verify IDCMP messages:
  875.    newflags &= ~(IDCMP_SIZEVERIFY | IDCMP_REQVERIFY | IDCMP_MENUVERIFY);
  876.  
  877.    ModifyIDCMP( wptr, newflags );
  878.    
  879.    answer = EasyRequest( wptr, &userinfo.un_ES, NULL, errnum );
  880.  
  881.    switch (answer)
  882.       {
  883.       case 1:
  884.          rval = RETURN_OK; // Continue Button.
  885.          break;
  886.          
  887.       case 0:        // This is the far right button!
  888.          rval = -1;
  889.          break;
  890.       }
  891.  
  892.    ModifyIDCMP( wptr, oldflags ); // Restore old IDCMP flags.
  893.    return( rval );
  894. }
  895.  
  896. /****h* Handle_Problem() [1.0] **************************************
  897. *
  898. * NAME
  899. *    Handle_Problem()
  900. *
  901. * SYNOPSIS
  902. *    int ans = Handle_Problem( char *info, char *title, int *errnum );
  903. *
  904. * DESCRIPTION
  905. *    Get a Yes/No Response from the user.
  906. *
  907. * FUNCTION
  908. *    Return -1 if the user selected the ABORT (far-right) button,
  909. *    else return the errnum value (normally 0).
  910. *
  911. * INPUTS
  912. *    info   - Information string for the user to act on.
  913. *    title  - Title of the Problem Requester.
  914. *    errnum - Optional error number (normally NULL).
  915. *
  916. * NOTES
  917. *    Be sure to call SetNotifyWindow( wptr ) BEFORE using this 
  918. *    function for the first time!
  919. *********************************************************************
  920. *
  921. */
  922.  
  923. PUBLIC int Handle_Problem( char *info, char *title, int *errnum )
  924. {
  925.    int errornum = 0;
  926.    
  927.    if (errnum != NULL)
  928.       errornum = *errnum;
  929.       
  930.    if (userinfo.un_Window == NULL)
  931.       return( -2 );
  932.       
  933.    if (NotifyUser( info, title, userinfo.un_Window, errornum ) == -1)
  934.       return( -1 );
  935.    else
  936.       return( errornum );  // User didn't press the ABORT button!
  937. }
  938.  
  939. /****h* GetUserResponse() [1.0] *************************************
  940. *
  941. * NAME
  942. *    GetUserResponse - Get a button response from the user.
  943. *
  944. * SYNOPSIS
  945. *    int ans = GetUserResponse( char *info, char *title, int *errnum );
  946. *
  947. * FUNCTION
  948. *    Return -1 if there's no window, otherwise return the ordinal
  949. *    of the button the user pressed.  This means that there can be
  950. *    more than two choice buttons for the User to choose from.
  951. *
  952. * INPUTS
  953. *    info   - Information string for the user to act on.
  954. *    title  - Title of the Problem Requester.
  955. *    errnum - Optional error number.
  956. *
  957. * NOTES
  958. *    GetUserResponse() will return 0 for the right-most button,
  959. *    instead of n, where n is the number of buttons.  This is the
  960. *    behavior of the EasyRequest() function (so don't blame me!).
  961. *
  962. *    Call SetReqButtons() before using this function &
  963. *    be sure to call SetNotifyWindow( wptr ) BEFORE using this 
  964. *    function for the first time!
  965. *********************************************************************
  966. *
  967. */
  968.  
  969. PUBLIC int  GetUserResponse( char *problem, char *title, int *errnum )
  970. {
  971.    struct Window *wptr = userinfo.un_Window;
  972.    int            answer = 0;
  973.    int            oldflags, newflags, errornum;
  974.    
  975.    if (wptr == NULL)
  976.       return( -1 );
  977.       
  978.    if (errnum != NULL)
  979.       errornum = *errnum;
  980.       
  981.    newflags                     = wptr->IDCMPFlags;
  982.    userinfo.un_ES.es_TextFormat = problem;
  983.    userinfo.un_ES.es_Title      = title;
  984.    oldflags                     = newflags;
  985.    
  986.    // Turn off verify IDCMP messages:
  987.    newflags &= ~(IDCMP_SIZEVERIFY | IDCMP_REQVERIFY | IDCMP_MENUVERIFY);
  988.  
  989.    ModifyIDCMP( wptr, newflags );
  990.    
  991.    answer = EasyRequest( wptr, &userinfo.un_ES, NULL, errnum );
  992.  
  993.    ModifyIDCMP( wptr, oldflags ); // Restore old IDCMP flags.
  994.  
  995.    return( answer );
  996.    
  997. }
  998.  
  999. /****h* SanityCheck() [1.0] **************************************
  1000. *
  1001. * NAME
  1002. *    SanityCheck - Get a Yes/No Response from the user.
  1003. *
  1004. * SYNOPSIS
  1005. *    Boolean answer = SanityCheck( char *question );
  1006. *
  1007. * FUNCTION
  1008. *    Return TRUE if the User pressed the 'YES' button.
  1009. *    Return FALSE if the User pressed the 'NO' button.
  1010. *
  1011. * INPUTS
  1012. *    question - question the User has to respond to.
  1013. *
  1014. * NOTES
  1015. *    Be sure to call SetNotifyWindow( wptr ) BEFORE using this 
  1016. *    function for the first time!
  1017. ******************************************************************
  1018. *
  1019. */
  1020.  
  1021. PUBLIC BOOL SanityCheck( char *question )
  1022. {
  1023.    BOOL rval = FALSE;
  1024.  
  1025.    SetReqButtons( "YES|NO" );   
  1026.  
  1027.    rval = Handle_Problem( question, "User SANITY CHECK:", NULL );
  1028.  
  1029.    SetReqButtons( "CONTINUE|ABORT" );   
  1030.  
  1031.    if (rval == 0)
  1032.       rval = TRUE;
  1033.    else 
  1034.       rval = FALSE;
  1035.       
  1036.    return( rval ); 
  1037. }
  1038.  
  1039. /****h* UserInfo() [1.0] *****************************************
  1040. *
  1041. * NAME
  1042. *    UserInfo()
  1043. *
  1044. * SYNOPSIS
  1045. *    void UserInfo( char *message, char *windowtitle );
  1046. *
  1047. * DESCRIPTION
  1048. *    Tell user some information.
  1049. *
  1050. * NOTES
  1051. *    Be sure to call SetNotifyWindow( wptr ) BEFORE using this 
  1052. *    function for the first time!
  1053. ******************************************************************
  1054. *
  1055. */
  1056.  
  1057. PUBLIC void UserInfo( char *msg, char *title )
  1058. {
  1059.    SetReqButtons( "OKAY" );   
  1060.  
  1061.    (void) Handle_Problem( msg, title, NULL );
  1062.  
  1063.    SetReqButtons( "CONTINUE|ABORT" );   
  1064.  
  1065.    return; 
  1066. } 
  1067.  
  1068. /****h* ComputeX() [1.0] ********************************************
  1069. *
  1070. * NAME
  1071. *    ComputeX()
  1072. *
  1073. * SYNOPSIS
  1074. *    UWORD size = ComputeX( UWORD fontxsize, UWORD value );
  1075. *
  1076. * DESCRIPTION
  1077. *    This function returns (fontxsize * value + 4) / 8
  1078. *
  1079. * NOTES
  1080. *    This function will probably be changed to private later.
  1081. *********************************************************************
  1082. *
  1083. */
  1084.  
  1085. PUBLIC UWORD ComputeX( UWORD fontxsize, UWORD value )
  1086. {
  1087.    return( (UWORD) (((fontxsize * value) + 4) / 8) );
  1088. }
  1089.  
  1090. /****h* ComputeY() [1.0] ********************************************
  1091. *
  1092. * NAME
  1093. *    ComputeY()
  1094. *
  1095. * SYNOPSIS
  1096. *    UWORD size = ComputeY( UWORD fontysize, UWORD value );
  1097. *
  1098. * DESCRIPTION
  1099. *    This function returns (fontysize * value + 4) / 8
  1100. *
  1101. * NOTES
  1102. *    This function will probably be changed to private later.
  1103. *********************************************************************
  1104. *
  1105. */
  1106.  
  1107. PUBLIC UWORD ComputeY( UWORD fontysize, UWORD value )
  1108. {
  1109.    return( (UWORD) (((fontysize * value) + 4) / 8) );
  1110. }
  1111.  
  1112. /****h* ComputeFont() [1.0] *****************************************
  1113. *
  1114. * NAME
  1115. *    ComputeFont()
  1116. *
  1117. * SYNOPSIS
  1118. *    void ComputeFont( struct Screen   *screen,
  1119. *                      struct TextAttr *font,
  1120. *                      struct CompFont *cfont,
  1121. *                      UWORD            width,
  1122. *                      UWORD            height
  1123. *                    );
  1124. *
  1125. * DESCRIPTION
  1126. *    Initialize the CompFont structure according to the supplied
  1127. *    values in the font, width & height.  If the results won't fit
  1128. *    the screen dimensions, use topaz (8) in the computations
  1129. *    instead.
  1130. *
  1131. * NOTES
  1132. *    GfxBase has to be open BEFORE calling this function!
  1133. *********************************************************************
  1134. *
  1135. */
  1136.  
  1137. PUBLIC void ComputeFont( struct Screen   *Scr, 
  1138.                          struct TextAttr *Font,
  1139.                          struct CompFont *cf,
  1140.                          UWORD            width, 
  1141.                          UWORD            height
  1142.                        )
  1143. {
  1144.    if (GfxBase == NULL)
  1145.       goto UseTopaz;
  1146.       
  1147.    Forbid(); // ---------------------------------------------
  1148.      
  1149.      Font->ta_Name  = (STRPTR) 
  1150.                       GfxBase->DefaultFont->tf_Message.mn_Node.ln_Name;
  1151.      
  1152.      Font->ta_YSize = GfxBase->DefaultFont->tf_YSize;
  1153.      
  1154.      cf->FontY = GfxBase->DefaultFont->tf_YSize; 
  1155.      cf->FontX = GfxBase->DefaultFont->tf_XSize; 
  1156.      
  1157.    Permit(); // ---------------------------------------------
  1158.  
  1159.    cf->OffX = Scr->WBorLeft;
  1160.    cf->OffY = Scr->RastPort.TxHeight + Scr->WBorTop + 1;
  1161.  
  1162.    if ((width != 0) && (height != 0))
  1163.       {
  1164.       if ((ComputeX( cf->FontX, width ) 
  1165.            + cf->OffX + Scr->WBorRight) > Scr->Width)
  1166.          goto UseTopaz;
  1167.          
  1168.       if ((ComputeY( cf->FontY, height ) 
  1169.            + cf->OffY + Scr->WBorBottom) > Scr->Height)
  1170.          goto UseTopaz;
  1171.       }   
  1172.  
  1173.    return;
  1174.    
  1175. UseTopaz:
  1176.  
  1177.    Font->ta_Name  = (STRPTR) "topaz.font";
  1178.    Font->ta_YSize = 8;
  1179.    
  1180.    cf->FontX      = 8;
  1181.    cf->FontY      = 8;
  1182.  
  1183.    // These might be in error:
  1184.    cf->OffX       = Scr->WBorLeft;
  1185.    cf->OffY       = Scr->RastPort.TxHeight + Scr->WBorTop + 1;
  1186.  
  1187.    return;
  1188. }
  1189.  
  1190. /****h* FindTools() [1.0] *******************************************
  1191. *
  1192. * NAME
  1193. *    FindTools()
  1194. * 
  1195. * DESCRIPTION
  1196. *    Locate a tools array for a given name.
  1197. *
  1198. * SYNOPSIS
  1199. *    char **toolarray = FindTools( struct DiskObject *diskobj,
  1200. *                                  char              *filename,
  1201. *                                  BPTR               directory_lock
  1202. *                                );
  1203. *
  1204. * INPUTS
  1205. *    filename = null-terminated name of file to look for.
  1206. *    lock     = directory to look for file in.
  1207. *    diskobj  = storage (for a later call to FreeDiskObject()) 
  1208. *
  1209. * WARNINGS
  1210. *    Be sure to call FreeDiskObject() later in your program.
  1211. *    FindTools() doesn't do this because it doesn't know what 
  1212. *    you're going to do with the ToolTypes. 
  1213. *********************************************************************
  1214. *
  1215. */
  1216.  
  1217. PUBLIC char **FindTools( struct DiskObject *diskobj, 
  1218.                          char              *name, 
  1219.                          BPTR               lock 
  1220.                        )
  1221. {
  1222.    BPTR   olddir = NULL;
  1223.    char **tools  = NULL;
  1224.  
  1225.    if (lock == NULL)
  1226.       return( NULL );
  1227.       
  1228.    olddir = CurrentDir( lock );
  1229.    
  1230.    if ((diskobj = (struct DiskObject *) GetDiskObject( name )) != NULL)
  1231.       tools = diskobj->do_ToolTypes;
  1232.    
  1233.    (void) CurrentDir( olddir );
  1234.  
  1235.    return( tools );
  1236. }
  1237.  
  1238. /****h* GetToolStr() [1.0] ******************************************
  1239. *
  1240. * NAME
  1241. *    GetToolStr()
  1242. *
  1243. * DESCRIPTION
  1244. *    Find the tooltype string that matches the given name.
  1245. *
  1246. * SYNOPSIS
  1247. *    toolstring = GetToolStr( char **toolarray,
  1248. *                             char  *toolname,
  1249. *                             char  *default_tool
  1250. *                           );
  1251. *
  1252. * INPUTS
  1253. *    toolarray    = pointer from FindTools() call.
  1254. *    toolname     = tool we're searching the icon for.
  1255. *    default_tool = default string to return if the tool isn't found.
  1256. *********************************************************************
  1257. *
  1258. */
  1259.  
  1260. PUBLIC char *GetToolStr( char **toolptr, char *name, char *deflt )
  1261. {
  1262.    char *found = NULL;
  1263.    
  1264.    found = (char *) FindToolType( toolptr, name );
  1265.  
  1266.    return( (found != NULL) ? found : deflt );
  1267. }
  1268.  
  1269. /****h* GetToolInt() [1.0] ******************************************
  1270. *
  1271. * NAME
  1272. *    GetToolInt() 
  1273. *
  1274. * DESCRIPTION
  1275. *    Find the tooltype integer that matches the given name.
  1276. *
  1277. * SYNOPSIS
  1278. *    tool_int = GetToolInt( char **toolarray,
  1279. *                           char  *toolname,
  1280. *                           int    default_val
  1281. *                         );
  1282. *
  1283. * INPUTS
  1284. *    toolarray   = pointer from FindTools() call.
  1285. *    toolname    = tool we're searching the icon for.
  1286. *    default_val = default integer to return if the tool isn't found.
  1287. *********************************************************************
  1288. *
  1289. */
  1290.  
  1291. PUBLIC int GetToolInt( char **toolptr, char *name, int defaultvalue )
  1292. {
  1293.    char *found = NULL;
  1294.    int   rval  = 0;
  1295.    
  1296.    found = (char *) FindToolType( toolptr, name );
  1297.  
  1298.    rval  = atoi( found );
  1299.  
  1300.    return( (rval > 0) ? rval : defaultvalue );
  1301. }
  1302.  
  1303. /****h* GetToolBoolean() [1.0] **************************************
  1304. *
  1305. * NAME
  1306. *    GetToolBoolean()
  1307. *
  1308. * DESCRIPTION
  1309. *    Find the tooltype boolean that matches the given name.
  1310. *
  1311. * SYNOPSIS
  1312. *    boolean ans = GetToolBoolean( char **toolptr,
  1313. *                                  char  *name,
  1314. *                                  int    defaultBool
  1315. *                                );
  1316. *
  1317. * INPUTS
  1318. *    toolptr     = pointer from FindTools() call.
  1319. *    name        = tool we're searching the icon for.
  1320. *    defaultBool = default boolean to return if the tool isn't found.
  1321. *
  1322. * NOTES
  1323. *    The following strings will return a Boolean value of TRUE:
  1324. *        
  1325. *        "TRUE", "YES", "OK" & "OKAY"
  1326. *
  1327. *    any other value will return FALSE.
  1328. *********************************************************************
  1329. *
  1330. */
  1331.  
  1332. PUBLIC BOOL GetToolBoolean( char **toolptr, char *name, int defaultBool )
  1333. {
  1334.    char *found = NULL;
  1335.    
  1336.    found = (char *) FindToolType( toolptr, name );
  1337.  
  1338.    if (found != NULL)
  1339.       {
  1340.       if (strcmp( found, "TRUE" ) == 0)
  1341.          return( TRUE );
  1342.       else if (strcmp( found, "YES"  ) == 0)
  1343.          return( TRUE );
  1344.       else if (strcmp( found, "OK"   ) == 0)
  1345.          return( TRUE );
  1346.       else if (strcmp( found, "OKAY" ) == 0)
  1347.          return( TRUE );
  1348.       else
  1349.          return( FALSE );
  1350.       }
  1351.    else
  1352.       return( (BOOL) defaultBool );
  1353. }
  1354.  
  1355. /****h* FindIcon() [1.0] ********************************************
  1356. *
  1357. * NAME
  1358. *    FindIcon()
  1359. *
  1360. * DESCRIPTION
  1361. *    Find the icon associated with pgmname (if any) & process the
  1362. *    ToolTypes array in the icon with ToolProc().
  1363. *
  1364. * SYNOPSIS
  1365. *    void *rval = FindIcon( void              *(ToolProc)(char **), 
  1366. *                           struct DiskObject *dobj,
  1367. *                           char              *pgmname
  1368. *                         );
  1369. *
  1370. * INPUTS
  1371. *    ToolProc() - a Pointer to a function that will perform an
  1372. *                 operation on the ToolTypes array from the Icon
  1373. *                 if the icon was found.
  1374. *
  1375. *    dobj       - storage (for a later call to FreeDiskObject())
  1376. *
  1377. *    pgmname    - The name of the icon to look for (without the
  1378. *                 ".info" at the end of the string). 
  1379. *
  1380. * NOTES
  1381. *    If the user starts a program from the CLI, & the icon is in
  1382. *    the same directory, we will get the ToolTypes from the icon
  1383. *    instead of using the built-in defaults.
  1384. *********************************************************************
  1385. *
  1386. */
  1387.  
  1388. PUBLIC void *FindIcon( void              *(ToolProc)(char **), 
  1389.                        struct DiskObject *dobj,
  1390.                        char              *pgmname
  1391.                      )
  1392. {
  1393.    BPTR   dirlock = NULL;
  1394.    char **toolptr = NULL;
  1395.    void  *rval    = NULL;
  1396.    
  1397.    dirlock = GetProgramDir(); // AmigaDOS function.
  1398.    
  1399.    if (dirlock != NULL)
  1400.       {
  1401.       toolptr = FindTools( dobj, pgmname, dirlock );
  1402.       rval    = ToolProc( toolptr ); // Do something with the tools!
  1403.       }
  1404.  
  1405.    return( rval );
  1406. }
  1407.  
  1408. /****h* CloseLibs() [1.0] *******************************************
  1409. *
  1410. * NAME
  1411. *    CloseLibs()
  1412. *
  1413. * SYNOPSIS
  1414. *    void CloseLibs( void );
  1415. *
  1416. * DESCRIPTION
  1417. *    Close the three most-commonly used libraries - 
  1418. *
  1419. *       intuition.library, graphics.library & gadtools.library.
  1420. *********************************************************************
  1421. *
  1422. */
  1423.  
  1424. PUBLIC void CloseLibs( void )
  1425. {
  1426.    if (IntuitionBase != NULL)
  1427.       CloseLibrary( (struct Library *) IntuitionBase );
  1428.  
  1429.    if (GfxBase != NULL)
  1430.       CloseLibrary( (struct Library *) GfxBase );
  1431.  
  1432.    if (GadToolsBase != NULL)
  1433.       CloseLibrary( GadToolsBase );
  1434.       
  1435.    return;
  1436. }
  1437.  
  1438. /****h* OpenLibs() [1.0] ********************************************
  1439. *
  1440. * NAME
  1441. *    OpenLibs()
  1442. *
  1443. * SYNOPSIS
  1444. *    int result = OpenLibs( void );
  1445. *
  1446. * DESCRIPTION
  1447. *    Open the three most-commonly used libraries (V39+) - 
  1448. *
  1449. *       intuition.library, graphics.library & gadtools.library.
  1450. *
  1451. * RETURN VALUE
  1452. *    Negative integer if a library could NOT be opened, zero if
  1453. *    all was successful.
  1454. *********************************************************************
  1455. *
  1456. */
  1457.  
  1458. PUBLIC int OpenLibs( void )
  1459. {
  1460.    IntuitionBase = (struct IntuitionBase *)
  1461.                    OpenLibrary( "intuition.library", 39L );
  1462.  
  1463.    if (IntuitionBase == NULL)
  1464.       return( -1 );
  1465.  
  1466.    GfxBase = (struct GfxBase *)
  1467.              OpenLibrary( "graphics.library", 39L );
  1468.  
  1469.    if (GfxBase == NULL)
  1470.       {
  1471.       CloseLibs();
  1472.       return( -2 );
  1473.       }
  1474.  
  1475.    GadToolsBase = OpenLibrary( "gadtools.library", 39L );
  1476.  
  1477.    if (GadToolsBase == NULL)
  1478.       {
  1479.       CloseLibs();
  1480.       return( -3 );
  1481.       }
  1482.  
  1483.    return( 0 );
  1484. }
  1485.  
  1486. /****h* RGB2HSV() ***************************************************
  1487. *
  1488. * NAME
  1489. *    RGB2HSV()
  1490. *
  1491. * SYNOPSIS
  1492. *    struct ColorCoords *ans = RGB2HSV( struct ColorCoords *input );
  1493. *
  1494. * DESCRIPTION
  1495. *    Convert an RGB color coordinate set into HSV (Hue,
  1496. *    Saturation & Luminance).
  1497. *
  1498. * NOTES
  1499. *    red, green & blue are values from 0 to 255 (normally).
  1500. *
  1501. * WARNINGS
  1502. *    If you want the input structure for later, save it before
  1503. *    passing it to this function, since it modifies it & returns it.
  1504. *********************************************************************
  1505. *
  1506. */
  1507.  
  1508. PUBLIC struct ColorCoords *RGB2HSV( struct ColorCoords *input )
  1509. {
  1510.    float hue, saturation, luminance;
  1511.    float red, green, blue;
  1512.    float ma, mi, d;
  1513.    
  1514.    red   = (float) input->Red_Hue          / 15;
  1515.    green = (float) input->Green_Saturation / 15;
  1516.    blue  = (float) input->Blue_Luminance   / 15;
  1517.  
  1518.    ma = (red > blue)  ? red : blue;
  1519.    ma = (ma  > green) ? ma  : green;
  1520.    mi = (red < blue)  ? red : blue;
  1521.    mi = (mi  < green) ? mi  : green;
  1522.  
  1523.    luminance = ma;
  1524.    
  1525.    if (ma != 0)
  1526.       saturation = (ma - mi) / ma;
  1527.    else
  1528.       saturation = 0;
  1529.       
  1530.    if (saturation == 0)
  1531.       hue = 0;
  1532.    else
  1533.       {
  1534.       d = ma - mi;
  1535.       
  1536.       if (red == ma)
  1537.          hue = (green - blue) / d;
  1538.       else if (green == ma)
  1539.          hue = 2 + (blue - red) / d;
  1540.       else
  1541.          hue = 4 + (red - green) / d;
  1542.  
  1543.       hue *= 60;
  1544.       
  1545.       if (hue < 0)
  1546.          hue += 360;
  1547.       }
  1548.  
  1549.    input->Red_Hue          = (LONG) hue;
  1550.    input->Green_Saturation = (LONG) 100 * saturation;
  1551.    input->Blue_Luminance   = (LONG) 100 * luminance;
  1552.  
  1553.    return( input );
  1554. }
  1555.  
  1556. /****h* HSV2RGB() ***************************************************
  1557. *
  1558. * NAME
  1559. *    HSV2RGB()
  1560. *
  1561. * SYNOPSIS
  1562. *    struct ColorCoords *ans = HSV2RGB( struct ColorCoords *input );
  1563. *
  1564. * DESCRIPTION 
  1565. *    Convert an HSV (Hue, Saturation & Luminance) coordinate into
  1566. *    RGB (red, green & blue).
  1567. *
  1568. * NOTES
  1569. *    red, green & blue are values from 0 to 255 (normally).
  1570. *
  1571. * WARNINGS
  1572. *    If you want the input structure for later, save it before
  1573. *    passing it to this function, since it modifies it & returns it.
  1574. *
  1575. *********************************************************************
  1576. *
  1577. */
  1578.  
  1579. PUBLIC struct ColorCoords *HSV2RGB( struct ColorCoords *input )
  1580. {
  1581.    float hue, saturation, luminance;
  1582.    float red, green, blue;
  1583.    float p1, p2, p3, f;
  1584.    int   i = 0;
  1585.  
  1586.   hue        = (float) input->Red_Hue          / 60;
  1587.   luminance  = (float) input->Blue_Luminance   / 100;
  1588.   saturation = (float) input->Green_Saturation / 100;
  1589.  
  1590.   while ((f = hue - i) > 1)
  1591.     i++;
  1592.  
  1593.   p1 = luminance * (1 - saturation);
  1594.   p2 = luminance * (1 - (saturation * f));
  1595.   p3 = luminance * (1 - (saturation * (1 - f)));
  1596.  
  1597.   switch (i)
  1598.     {
  1599.     case 0:
  1600.       red   = luminance;
  1601.       green = p3;
  1602.       blue  = p1;
  1603.       break;
  1604.  
  1605.     case 1:
  1606.       red   = p2;
  1607.       green = luminance;
  1608.       blue  = p1;
  1609.       break;
  1610.  
  1611.     case 2:
  1612.       red   = p1;
  1613.       green = luminance;
  1614.       blue  = p3;
  1615.       break;
  1616.  
  1617.     case 3:
  1618.       red   = p1;
  1619.       green = p2;
  1620.       blue  = luminance;
  1621.       break;
  1622.  
  1623.     case 4:
  1624.       red   = p3;
  1625.       green = p1;
  1626.       blue  = luminance;
  1627.       break;
  1628.  
  1629.     case 5:
  1630.       red   = luminance;
  1631.       green = p1;
  1632.       blue  = p2;
  1633.       break;
  1634.     }
  1635.  
  1636.   input->Red_Hue          = (UWORD) (red   * 15);
  1637.   input->Green_Saturation = (UWORD) (green * 15);
  1638.   input->Blue_Luminance   = (UWORD) (blue  * 15);
  1639.  
  1640.   return( input );
  1641.  
  1642. }
  1643.  
  1644. /****h* SetTagItem() [1.0] ******************************************
  1645. *
  1646. * NAME
  1647. *    SetTagItem()
  1648. *
  1649. * SYNOPSIS
  1650. *    void SetTagItem( struct TagItem *taglist, ULONG tag, ULONG value );
  1651. *
  1652. * DESCRIPTION
  1653. *    This function searches the given taglist for the given tag.  If
  1654. *    the tag is found, its value (ti_Data) is changed to the given
  1655. *    value.  This function completes the functionality for using 
  1656. *    TagLists.
  1657. *********************************************************************
  1658. *
  1659. */
  1660.  
  1661. PUBLIC void SetTagItem( struct TagItem *taglist, ULONG tag, ULONG value )
  1662. {
  1663.    struct TagItem *item = (struct TagItem *) FindTagItem( tag, taglist );
  1664.    
  1665.    if (item != NULL)
  1666.       item->ti_Data = value;
  1667.    
  1668.    return;
  1669. }
  1670.  
  1671. /****h* SetTagPair() [1.0] ******************************************
  1672. *
  1673. * NAME
  1674. *    SetTagPair()
  1675. *
  1676. * SYNOPSIS
  1677. *    void SetTagPair( struct TagItem *taglist, ULONG tag, ULONG value );
  1678. *
  1679. * DESCRIPTION
  1680. *    Add a Tag & value to a TagItem list.  If taglist is NULL, 
  1681. *    nothing is done by this function.
  1682. *    This function completes the functionality for using TagLists.
  1683. *
  1684. * NOTES
  1685. *    taglist is really an array of ULONG values organized into pairs.
  1686. *
  1687. * WARNINGS
  1688. *    No check is done to see if there is space in the Tag list
  1689. *    for the added pair (so why not reserve space by using: 
  1690. *    {TAG_IGNORE, NULL} in the taglist you provide?).
  1691. *********************************************************************
  1692. *
  1693. */
  1694.  
  1695. PUBLIC void SetTagPair( struct TagItem *taglist, ULONG tag, ULONG value )
  1696. {
  1697.    if (taglist == NULL)
  1698.       return;            // Do NOT cause Enforcer hits.
  1699.       
  1700.    taglist->ti_Tag  = tag;
  1701.    taglist->ti_Data = value;   
  1702.  
  1703.    return;
  1704. }
  1705.  
  1706. /****h* FGetS() [1.0] **********************************************
  1707. *
  1708. * NAME
  1709. *    FGetS()
  1710. *
  1711. * SYNOPSIS
  1712. *    char *str = FGetS( char *buffer, int readlength, FILE *fptr );
  1713. *
  1714. * DESCRIPTION
  1715. *    This function is identical to the C library function fgets()
  1716. *    except that it changes the \n at the end of a line to a \0.
  1717. ********************************************************************
  1718. *
  1719. */
  1720.  
  1721. PUBLIC char *FGetS( char *buffer, int length, FILE *fileptr )
  1722. {
  1723.    char *rval = NULL, *cp = NULL;
  1724.    int   len  = 0;
  1725.    
  1726.    rval = fgets( buffer, length, fileptr );
  1727.    
  1728.    if (rval != NULL)
  1729.       {
  1730.       len = strlen( buffer ) - 1;
  1731.       
  1732.       cp = &buffer[ len ];
  1733.       
  1734.       if (*cp == '\n')
  1735.          *cp = '\0';
  1736.       }
  1737.  
  1738.    return( rval );
  1739. }
  1740.  
  1741. /****h* HideListFromView() ******************************************
  1742. *
  1743. * NAME
  1744. *    HideListFromView()
  1745. *
  1746. * SYNOPSIS
  1747. *    void HideListFromView( struct Gadget *listview_gadget,
  1748. *                           struct Window *window_pointer
  1749. *                         );
  1750. *
  1751. * DESCRIPTION
  1752. *    Turn off the Given ListView Gadget for the window, so that it
  1753. *    can be modified elsewhere.
  1754. *
  1755. * SEE ALSO
  1756. *    ModifyListView()
  1757. *********************************************************************
  1758. *
  1759. */ 
  1760.  
  1761. PUBLIC void HideListFromView( struct Gadget *lv, struct Window *w )
  1762. {
  1763.    GT_SetGadgetAttrs( lv, w, NULL, GTLV_Labels, ~0, TAG_DONE );
  1764.    return;
  1765. }
  1766.  
  1767. /****h* ModifyListView() ********************************************
  1768. *
  1769. * NAME
  1770. *    ModifyListView()
  1771. *
  1772. * SYNOPSIS
  1773. *    void ModifyLsitView( struct Gadget *listview_gadget,
  1774. *                         struct Window *window_pointer,
  1775. *                         struct List   *listview_contents,
  1776. *                         struct Gadget *string_gadget
  1777. *                       ); 
  1778. *
  1779. * DESCRIPTION
  1780. *    Change the Given ListView Gadget for the window to the 
  1781. *    new parameters, which will re-display it.
  1782. *
  1783. * SEE ALSO
  1784. *    HideListFromView()
  1785. *********************************************************************
  1786. *
  1787. */ 
  1788.  
  1789. PUBLIC void ModifyListView( struct Gadget *lv, 
  1790.                             struct Window *w,
  1791.                             struct List   *list,
  1792.                             struct Gadget *strgadget
  1793.                           )
  1794. {
  1795.    GT_SetGadgetAttrs( lv, w, NULL,
  1796.                       GTLV_Labels,       list,
  1797.                       GTLV_ShowSelected, strgadget,
  1798.                       GTLV_Selected,     0,
  1799.                       TAG_DONE
  1800.                     );
  1801.    return;
  1802. }
  1803.  
  1804. /* ---------------- END of CommonFuncs.c file! ----------------------- */
  1805.